package br.com.android.financas.repositorio.impl;

import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.joda.time.DateTime;
import org.joda.time.Interval;
import org.joda.time.Period;
import org.joda.time.PeriodType;

import android.content.Context;
import br.com.android.financas.CategoriaTotal;
import br.com.android.financas.MesTotal;
import br.com.android.financas.model.Apresentavel;
import br.com.android.financas.model.Categoria;
import br.com.android.financas.model.Despesa;
import br.com.android.financas.model.Recorrente;
import br.com.android.financas.repositorio.RepositorioCategoria;
import br.com.android.financas.repositorio.RepositorioDespesa;
import br.com.android.financas.repositorio.RepositorioGenerico;

import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.dao.GenericRawResults;

public class RepositorioDespesaImpl extends RepositorioGenerico<Despesa>
		implements RepositorioDespesa {

	public RepositorioDespesaImpl(Context context) throws SQLException {
		super(context);
	}

	private double getTotal(List<Despesa> despesas) {
		double total = 0;
		for (Despesa despesa : despesas) {
			total += despesa.getValor();
		}
		return total;
	}

	public double getTotal() {

		double total=0;
		try {
			total = getDatabase().queryRawValue("select sum(valor) from despesa");
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return total;
	}

	@Override
	public double getTotal(Date mes) {

		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

		return getTotal(ini.toDate(), fim.toDate());
	}

	@Override
	public double getTotal(Date ini, Date fim) {

		try {

			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select sum(valor) from despesa where date(data/1000,'unixepoch','localtime') between ? and ?", new SimpleDateFormat("yyyy-MM-dd").format(ini)  ,new SimpleDateFormat("yyyy-MM-dd").format(fim));
			return Double.parseDouble(rawResults.getFirstResult()[0]);

		} catch (Exception e) {
			return 0;
		}
	}

	@Override
	public double getTotal(Categoria categoria) {
		double total=0;
		try {
			total = getDatabase().queryRawValue("select sum(valor) from despesa where categoria=?",categoria.getId().toString());
		} catch (Exception e) {
			total=0;
		}

		return total;
	}

	@Override
	public double getTotal(Date mes, Categoria categoria) {
		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

		//QueryBuilder<Despesa, Integer> query = getDatabase().queryBuilder();
		List<Despesa> despesas=new ArrayList<Despesa>();
		Interval intervalo= new Interval(ini,fim);
		List<Despesa> tmpDespesas=getDespesas(categoria);

		for(Despesa despesa:tmpDespesas){

			if(intervalo.contains(despesa.getData().getTime()))
				despesas.add(despesa);
		}

		return getTotal(despesas);
	}

	@Override
	public List<Despesa> getDespesas(Categoria categoria) {

		try {
			return getDatabase().queryForEq("categoria", categoria);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return Collections.emptyList();
	}

	@Override
	public Map<Categoria, List<Despesa>> getCategorias(Date mes) {

		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

		return getCategorias(ini.toDate(), fim.toDate());
	}

	@Override
	public Map<Categoria, List<Despesa>> getCategorias(Date ini, Date fim) {

		List<Despesa> despesas = getDespesas(ini, fim);
		Map<Categoria, List<Despesa>> categorias = new HashMap<Categoria, List<Despesa>>();

		for (Despesa despesa : despesas) {

			if (!categorias.containsKey(despesa.getCategoria())) {
				categorias
						.put(despesa.getCategoria(), new ArrayList<Despesa>());
			}

			categorias.get(despesa.getCategoria()).add(despesa);
		}

		return categorias;
	}

	@Override
	public List<CategoriaTotal> getCategoriasTotal(Date mes) {
		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();
		return getCategoriasTotal(ini.toDate(),fim.toDate());
	}

	@Override
	public List<CategoriaTotal> getCategoriasTotal(Date ini, Date fim) {
		try {
			String sini=new SimpleDateFormat("yyyy-MM-dd").format(ini);
			String sfim=new SimpleDateFormat("yyyy-MM-dd").format(fim);

			RepositorioCategoria repositorioCategoria=new RepositorioCategoriaImpl(context);
			List<CategoriaTotal> lista=new ArrayList<CategoriaTotal>();
			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select categoria,sum(valor),(sum(valor))/(select sum(valor) from despesa where date(data/1000,'unixepoch','localtime') between ? and ?) from despesa where date(data/1000,'unixepoch','localtime') between ? and ? group by categoria",
					sini,sfim,sini,sfim);

			for (String[] resultArray : rawResults) {
				CategoriaTotal categoriaTotal= new CategoriaTotal();
				categoriaTotal.setCategoria(repositorioCategoria.obterPorId(Integer.parseInt(resultArray[0])));
				categoriaTotal.setTotal(Double.parseDouble(resultArray[1]));
				categoriaTotal.setPercentual(Double.parseDouble(resultArray[2]));

				lista.add(categoriaTotal);
			}

			return lista;


		} catch (SQLException e) {
			return Collections.emptyList();
		}
	}

	@Override
	public List<Despesa> getDespesas(Date mes) {
		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

		//Date i= new Date(ini.getYear(),ini.getMonthOfYear()-1,ini.getDayOfMonth(),0,0,0);
		//Date f= new Date(fim.getYear(),fim.getMonthOfYear()-1,fim.getDayOfMonth(),23,59,59);

		return getDespesas(ini.toDate(),fim.toDate());
	}

	@Override
	public List<Despesa> getDespesas(Date ini, Date fim) {

		try {
			return  getDatabase().queryBuilder().where().between("data", ini, fim).query();  //.or().eq("data", ini).or().eq("data", fim).query();
		} catch (SQLException e1) {}
		return Collections.emptyList();
	}


	@Override
	public List<Despesa> getDespesas(Categoria categoria, Date mes) {

		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();
		try {
			return  getDatabase().queryBuilder().where().between("data", ini.toDate(), fim.toDate()).and().eq("categoria", categoria).query();
		} catch (SQLException e1) {}
		return Collections.emptyList();

	}

	@Override
	public Map<DateTime, Double> getDespesasMensais(Date ini, Date fim) {

		Map<DateTime, Double> despesas = new LinkedHashMap<DateTime, Double>();

		Period p = new Period(ini.getTime(), fim.getTime());
		int qtd = p.getMonths();

		for (int i = 0; i <= qtd; i++) {
			DateTime d = (new DateTime(ini.getTime())).plusMonths(i);

			double total = getTotal(d.toDate());

			despesas.put(d, total);

		}

		return despesas;
	}

	@Override
	public Map<DateTime, Double> getDespesasMensais(Date ini, Date fim, Categoria categoria) {

		Map<DateTime, Double> despesas = new LinkedHashMap<DateTime, Double>();

		Period p = new Period(ini.getTime(), fim.getTime());
		int qtd = p.getMonths();

		for (int i = 0; i <= qtd; i++) {
			DateTime d = (new DateTime(ini.getTime())).plusMonths(i);

			double total = getTotal(d.toDate(),categoria);

			despesas.put(d, total);

		}

		return despesas;
	}

	@Override
	public Map<MesTotal, List<Apresentavel>> getDespesasMensais() {
		Map<MesTotal, List<Apresentavel>> meses = new LinkedHashMap<MesTotal, List<Apresentavel>>();
		List<Despesa> despesas = listar();

		Map<DateTime, MesTotal> mesesIncluidos = new HashMap<DateTime, MesTotal>();

		for (Despesa despesa : despesas) {

			DateTime tMes = (new DateTime(despesa.getData().getTime())).dayOfMonth().withMinimumValue().withTimeAtStartOfDay();

			if (!mesesIncluidos.containsKey(tMes)) {
				MesTotal mes = new MesTotal();
				mes.setMes(tMes);
				mes.setTotal(getTotal(tMes.toDate()));

				mesesIncluidos.put(tMes, mes);
				meses.put(mes, new ArrayList<Apresentavel>());
			}

			meses.get(mesesIncluidos.get(tMes)).add(despesa);

		}

		return meses;
	}

	@Override
	public Map<MesTotal, List<Apresentavel>> getDespesasMensais(
			Categoria categoria) {
		Map<MesTotal, List<Apresentavel>> meses = new LinkedHashMap<MesTotal, List<Apresentavel>>();
		List<Despesa> despesas = listar();

		Map<DateTime, MesTotal> mesesIncluidos = new HashMap<DateTime, MesTotal>();

		for (Despesa despesa : despesas) {
			if (despesa.getCategoria().equals(categoria)) {
				DateTime tMes = (new DateTime(despesa.getData().getTime()))
						.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();

				if (!mesesIncluidos.containsKey(tMes)) {
					MesTotal mes = new MesTotal();
					mes.setMes(tMes);
					mes.setTotal(getTotal(tMes.toDate(), categoria));

					mesesIncluidos.put(tMes, mes);
					meses.put(mes, new ArrayList<Apresentavel>());
				}

				meses.get(mesesIncluidos.get(tMes)).add(despesa);
			}

		}

		return meses;
	}

	@Override
	public void excluir(Despesa despesa, Date aPartir) throws SQLException {
		List<Despesa> despesas;
		if (!despesa.isPai()) {
			ForeignCollection<Despesa> t = despesa.getPai().getFilhos();
			despesas = new ArrayList<Despesa>();
			despesas.addAll(t);
			despesas.remove(despesa);
		} else {
			ForeignCollection<Despesa> t = despesa.getFilhos();
			despesas = new ArrayList<Despesa>();
			despesas.addAll(t);
		}

		DateTime ini = new DateTime(aPartir.getTime());

		for (Despesa d : despesas) {
			DateTime mes = new DateTime(d.getData().getTime());

			if (mes.isAfter(ini))
				excluir(d);
		}
		excluir(despesa);

	}

	@Override
	public void excluir(Despesa despesa, boolean todos) throws SQLException {
		List<Despesa> despesas;
		if (!despesa.isPai()) {
			despesas = new ArrayList<Despesa>(despesa.getPai().getFilhos());
			excluir(despesa);
			excluir(despesas);
		} else {
			despesas = new ArrayList<Despesa>(despesa.getFilhos());
			excluir(despesas);
			excluir(despesa);
		}
	}

	@Override
	public void atualizarGrupo(Despesa despesa) throws SQLException {
		Despesa pai;
		List<Despesa> despesas;
		if (!despesa.isPai()) {
			pai=despesa.getPai();
		} else {
			pai=despesa;
		}
		despesas=new ArrayList<Despesa>(pai.getFilhos());

		String descricao=pai.getDescricao();
		descricao=descricao.replaceAll("\\d+\\/\\d+", "");
		descricao=descricao.trim();

		DateTime ini = new DateTime(pai.getData().getTime());
		double valor = despesa.getValor();
		Categoria categoria = despesa.getCategoria();
		int i=1;
		int qtd=despesas.size()+1;

		for (Despesa d : despesas) {
			d.setCategoria(categoria);
			d.setValor(valor);
			if(d.getRecorrente()==null)
				d.setDescricao(descricao + " " + (i + 1) + "/" + qtd);
			else
				d.setDescricao(descricao);
			d.setData( ini.plusMonths(i).toDate());
			atualizar(d);
			i++;
		}
		if(pai.getRecorrente()!=null)
			pai.setDescricao(descricao);
		else
			pai.setDescricao(descricao + " 1/" + qtd);
		atualizar(pai);
	}

	@Override
	public void atualizarGrupo(Despesa despesa, Date aPartir)
			throws SQLException {

		if(despesa.isPai())
			atualizarGrupo(despesa);
		else{
			//List<Despesa> despesas=	getDatabase().queryBuilder().orderBy("data", true).where().eq("pai_id", despesa.getPai()).and().gt("data", despesa.getData()).query();
			List<Despesa> despesas=new ArrayList<Despesa>();
			List<Despesa> tmpDespesas=listar();

			for(Despesa d:tmpDespesas){
				if(d.getPai()!=null)
					if(d.getPai().equals(despesa.getPai()) && d.getData().after(despesa.getData()))
						despesas.add(d);
			}

			DateTime ini = new DateTime(despesa.getPai().getData().getTime());
			DateTime fim = new DateTime(despesa.getData().getTime());

			Period p = new Period(ini, fim, PeriodType.months().withDaysRemoved());
			int descCount = p.getMonths()+1;
			int qtd=despesa.getPai().getFilhos().size()+1;
			int i= 1;

			String descricao=despesa.getDescricao();
			descricao=descricao.replaceAll("\\d+\\/\\d+", "");
			descricao=descricao.trim();
			if(despesa.getRecorrente()!=null)
				despesa.setDescricao(descricao);

			double valor = despesa.getValor();
			Categoria categoria = despesa.getCategoria();
			for(Despesa d:despesas){
				if(d.getRecorrente()==null)
					d.setDescricao(descricao + " " + (descCount + 1) + "/" + qtd);
				else
					d.setDescricao(descricao);

				d.setValor(valor);
				d.setCategoria(categoria);
				d.setData( fim.plusMonths(i).toDate());
				atualizar(d);
				i++;
				descCount++;
			}
			atualizar(despesa);

		}
	}

	@Override
	public void atualizarDescricao(Despesa despesa) throws SQLException {
		Despesa pai;
		List<Despesa> despesas;
		if (!despesa.isPai()) {
			pai=despesa.getPai();
		} else {
			pai=despesa;
		}
		despesas=new ArrayList<Despesa>(pai.getFilhos());

		String descricao=despesa.getDescricao();
		descricao=descricao.replaceAll("\\d+\\/\\d+", "");
		descricao=descricao.trim();
		int i= 2;
		int qtd=despesas.size()+1;
		for(Despesa d:despesas){
			d.setDescricao(descricao + " " + i + "/" + qtd);
			atualizar(d);
			i++;
		}
		pai.setDescricao(descricao + " 1/" + qtd);
		atualizar(pai);
	}

	@Override
	public List<DateTime> getMeses() {
	/*	List<DateTime> meses=new ArrayList<DateTime>();

		List<Despesa> despesas=getDatabase().queryBuilder().groupByRaw("strftime('%Y-%m',data)").query();

		for(Despesa despesa: despesas){

		}


		return new ArrayList<DateTime>(meses);*/
		List<DateTime> meses=new ArrayList<DateTime>();
		GenericRawResults<String[]> rawResults;
		try {
			rawResults = getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime') from despesa group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))");

			for (String[] resultArray : rawResults) {
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					meses.add(data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay());

				} catch (ParseException e) {
				}

			}
			return meses;
		} catch (SQLException e) {
			return Collections.emptyList();
		}
	}

	@Override
	public List<DateTime> getMeses(Date mes) {
		/*Set<DateTime> meses=new HashSet<DateTime>();

		Date m=new DateTime(mes.getTime()).dayOfMonth().withMinimumValue().withTimeAtStartOfDay().toDate();

		QueryBuilder<Despesa, Integer> query = getDatabase().queryBuilder();
		//List<Despesa> despesas = query.where().ge("data", m).query();
		List<Despesa> despesas =new ArrayList<Despesa>();
		List<Despesa> tmpDespesas=listar();

		for(Despesa despesa:tmpDespesas){
			if(despesa.getData().equals(mes) || despesa.getData().after(mes) )
				despesas.add(despesa);
		}


		for(Despesa despesa:despesas){
			meses.add(new DateTime(despesa.getData().getTime()).dayOfMonth().withMinimumValue().withTimeAtStartOfDay());
		}

		return new ArrayList<DateTime>(meses);*/

		Date m=new DateTime(mes.getTime()).dayOfMonth().withMinimumValue().withTimeAtStartOfDay().toDate();

		List<DateTime> meses=new ArrayList<DateTime>();
		GenericRawResults<String[]> rawResults;
		try {
			rawResults = getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime') from despesa where date(data/1000,'unixepoch','localtime')>=? group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))",new SimpleDateFormat("yyyy-MM-dd").format(m));

			for (String[] resultArray : rawResults) {
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					meses.add(data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay());

				} catch (ParseException e) {
				}

			}
			return meses;
		} catch (SQLException e) {
			return Collections.emptyList();
		}
	}

	@Override
	public List<Despesa> getRecorrentes(Recorrente recorrente) {
		//return listarPorAtributo("recorrente_id", recorrente);
		List<Despesa> despesas=new ArrayList<Despesa>();
		List<Despesa> tmpDespesas=listar();

		for(Despesa despesa:tmpDespesas){
			if(despesa.getRecorrente()!=null)
				if(despesa.getRecorrente().equals(recorrente))
					despesas.add(despesa);
		}
		return despesas;
	}

	@Override
	public List<Despesa> getRecorrentes(Recorrente recorrente, Date mes) {

		DateTime m = new DateTime(mes.getTime());

		DateTime ini = m.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
		DateTime fim = m.dayOfMonth().withMaximumValue().withTimeAtStartOfDay();


		//QueryBuilder<Despesa, Integer> query = getDatabase().queryBuilder();
		List<Despesa> despesas=new ArrayList<Despesa>();

		Interval intervalo= new Interval(ini,fim);
		List<Despesa> tmpDespesas=listar();
		for(Despesa despesa:tmpDespesas){
			if(despesa.getRecorrente()!=null)
				if(intervalo.contains(despesa.getData().getTime()) && despesa.getRecorrente().equals(recorrente))
					despesas.add(despesa);
		}

		return despesas;
	}

	@Override
	public List<MesTotal> getTotaisMensais() {

		try {
			List<MesTotal> totais=new ArrayList<MesTotal>();
			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime'),sum(valor) from despesa group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))");

			for (String[] resultArray : rawResults) {
				MesTotal mes= new MesTotal();
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					data=data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
					mes.setMes(data);
					mes.setTotal(Double.parseDouble(resultArray[1]));
					totais.add(mes);
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			rawResults.close();
			return totais;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return Collections.emptyList();
	}

	@Override
	public List<MesTotal> getTotaisMensais(Categoria categoria) {

		try {
			List<MesTotal> totais=new ArrayList<MesTotal>();
			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime'),sum(valor) from despesa where categoria=? group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))",categoria.getId().toString());

			for (String[] resultArray : rawResults) {
				MesTotal mes= new MesTotal();
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					data=data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
					mes.setMes(data);
					mes.setTotal(Double.parseDouble(resultArray[1]));
					totais.add(mes);
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			rawResults.close();
			return totais;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return Collections.emptyList();
	}

	@Override
	public List<MesTotal> getTotaisMensais(Date ini, Date fim,
			Categoria categoria) {
		try {

			DateTime i=(new DateTime(ini.getTime())).dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
			DateTime f=(new DateTime(fim.getTime())).dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

			List<MesTotal> totais=new ArrayList<MesTotal>();
			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime'),sum(valor) from despesa where date(data/1000,'unixepoch','localtime') between ? and ? and categoria=? group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))",new SimpleDateFormat("yyyy-MM-dd").format(i.toDate()),new SimpleDateFormat("yyyy-MM-dd").format(f.toDate()),categoria.getId().toString());

			for (String[] resultArray : rawResults) {
				MesTotal mes= new MesTotal();
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					data=data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
					mes.setMes(data);
					mes.setTotal(Double.parseDouble(resultArray[1]));
					totais.add(mes);
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			rawResults.close();
			return totais;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return Collections.emptyList();
	}
	@Override
	public List<MesTotal> getTotaisMensais(Date ini, Date fim) {
		try {

			DateTime i=(new DateTime(ini.getTime())).dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
			DateTime f=(new DateTime(fim.getTime())).dayOfMonth().withMaximumValue().withTimeAtStartOfDay();

			List<MesTotal> totais=new ArrayList<MesTotal>();
			GenericRawResults<String[]> rawResults= getDatabase().queryRaw("select date(data/1000,'unixepoch','localtime'),sum(valor) from despesa where date(data/1000,'unixepoch','localtime') between ? and ? group by strftime('%Y-%m',date(data/1000,'unixepoch','localtime'))",new SimpleDateFormat("yyyy-MM-dd").format(i.toDate()),new SimpleDateFormat("yyyy-MM-dd").format(f.toDate()));

			for (String[] resultArray : rawResults) {
				MesTotal mes= new MesTotal();
				try {
					DateTime data=new DateTime( new SimpleDateFormat("yyyy-MM-dd").parse(resultArray[0].split("\\.")[0]).getTime());
					data=data.dayOfMonth().withMinimumValue().withTimeAtStartOfDay();
					mes.setMes(data);
					mes.setTotal(Double.parseDouble(resultArray[1]));
					totais.add(mes);
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			rawResults.close();
			return totais;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return Collections.emptyList();
	}
}